/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package manejadores;

import com.akcess.exception.*;
import com.akcess.vo.*;
import com.akcess.impl.*;
import com.akcess.dao.*;
import java.sql.*;
import java.util.*;
/**
 *
 * @author Ramon
 */
public class ManejadorSubtiposRecursos {
    private Connection conexion = null;

    public ManejadorSubtiposRecursos(Connection con) {
        this.conexion = con;
    }
    
    /**
     * Agrega un nuevo subtipo a la tabla tipos_recursos y asigna tambien los atributos que tiene el recurso
     * @param tipito Es del Tipo_recurso, es el nuevo tipo que será agregado a la base de datos.
     * @param atributos Es el conjuntos de atributos que tiene el Tipo de Recurso nuevo agregado.
     * @throws com.akcess.exception.Tipo_tiene_atributosException Utilizado si metemos Tipos duplicados.
     */
    public void AgregarSubtipo(Tipo_recurso tipito, Vector atributos) throws Tipo_tiene_atributosException{
       try {            
            int id_nuevoTipo = 0;            
            //Agrego a la base de datos la nueva solicitud
            Tipo_recursoDAOImpl manejadorTipo = new Tipo_recursoDAOImpl();
            manejadorTipo.insert(tipito, this.conexion);
            Tipo_recurso [] TipoNuevo = manejadorTipo.findByNombre(tipito.getNombre(), this.conexion);
            id_nuevoTipo = TipoNuevo[0].getId_tipo_recurso();
            
             //Para agregar a la tabla que relaciona el id del nuevo tipo con un id de atributo.
            Tipo_tiene_atributosDAOImpl manejadorTiposAtributos = new Tipo_tiene_atributosDAOImpl();
            Tipo_tiene_atributos auxTipoAtributo = new Tipo_tiene_atributos();
            Atributos_recursos atribu = null;
            for (int i = 0; i < atributos.size(); i++) {
                atribu = (Atributos_recursos)atributos.get(i);
                auxTipoAtributo.setId_atributos(atribu.getId_atributos());
                auxTipoAtributo.setId_tipo_recurso(id_nuevoTipo);
                manejadorTiposAtributos.insert(auxTipoAtributo, this.conexion);
            }    
                  

        }  catch (Tipo_recursoException ex) {
            ex.printStackTrace();
        }
       
    }
     /**
     * Realiza el borrado de la BD de un Tipo_recurso determinado.
     * @param idTipo_recurso Contiene el id del Tipo de recurso que sera eliminado.
     * @throws com.akcess.exception.Tipo_recursoException Lanza excepciones del tipo Tipo_recursoException, creada por el DAOGenerator.
     */
    public void BorrarTipo(int idTipo) throws Tipo_recursoException {   
             //Me conecto a la BD           
            Tipo_recursoPK tipoPK = new Tipo_recursoPK();
            tipoPK.setId_tipo_recurso(idTipo);
            Tipo_recursoDAOImpl manejadorTipo = new Tipo_recursoDAOImpl();
            manejadorTipo.delete(tipoPK, this.conexion);
    }
    public void ModificarTipo(Tipo_recurso tipoNada) throws Tipo_recursoException {
            Tipo_recursoDAOImpl manejaTipo=new Tipo_recursoDAOImpl();
            Tipo_recursoPK TipoPK=new Tipo_recursoPK(tipoNada.getId_tipo_recurso());
            manejaTipo.update(TipoPK, tipoNada, this.conexion);
    }
    
    /**
     * Actualiza la base de datos con el nuevo conjunto de atributos que fueron modificados.
     * @param tipito Es el id del tipo de recurso que queremos modificar sus atributos.
     * @param atributosModificados Es el conjunto de los nuevos atributos.
     * @throws com.akcess.exception.Atributos_recursosException
     */
     public void ModificarAtributos(int tipito, Vector atributosModificados) throws Atributos_recursosException, Tipo_tiene_atributosException{
        Atributos_recursos [] atributosActuales= this.BuscarAtributosDeTipo(tipito);
        Tipo_tiene_atributosPK duplaPK= new Tipo_tiene_atributosPK();
        
        Tipo_tiene_atributosDAOImpl manejaRelacion= new Tipo_tiene_atributosDAOImpl();
        
        boolean band = false;
        int indice = 0;
        for (int i = 0; i < atributosActuales.length; i++) {
                for (int j = 0; j < atributosModificados.size(); j++) {
                    Atributos_recursos atribu = (Atributos_recursos) atributosModificados.get(j);
                    if (atributosActuales[i].getId_atributos() == atribu.getId_atributos()) {
                        band = true;
                        indice = j;
                        break;
                    }
                }
                if (band) {
                    //borrar de vector atributos que Subtipo ya tiene loo asignado.
                    atributosModificados.remove(indice);
                    band = false;
                } else {
                    //borrar de la base de datos los atributos que ya NO tengo.
                    duplaPK.setId_atributos(atributosActuales[i].getId_atributos());
                    duplaPK.setId_tipo_recurso(tipito);
                    manejaRelacion.delete(duplaPK, this.conexion);
                }
            }
            //Agregamos los nuevos atributos, esos solamente quedaran en el vector....
            for (int i = 0; i < atributosModificados.size(); i++) {
                Atributos_recursos atribu = (Atributos_recursos) atributosModificados.get(i);
                Tipo_tiene_atributos relacion= new Tipo_tiene_atributos();
                relacion.setId_atributos(atribu.getId_atributos());
                relacion.setId_tipo_recurso(tipito);
                manejaRelacion.insert(relacion, this.conexion);
            }
        
        
    }
   
    /**
     * Obtiene TODOS los atributos que tiene un tipo de recurso dado.
     * @return Un vector del tipo Atributos_recursos.
     * @throws com.akcess.exception.Tipo_tiene_atributosException Lanza excepciones del tipo Tipo_tiene_atributosExceptionException, creada por el DAOGenerator.
     */
    public Atributos_recursos [] BuscarAtributosDeTipo(int idTipo) throws Atributos_recursosException
    {
        Atributos_recursos[]atributos;
        Atributos_recursosDAOImpl maneja= new Atributos_recursosDAOImpl();
        atributos=maneja.BuscarAtributosDeTipo(idTipo, this.conexion);
        return atributos;
    }
   /**
    * Retorna todos los Tipos de Recurso que existen en la base de datos.
    * @return Tipo_recurso[], que es un vector que contiene a todos los tipos de recursos que existe en el sistema. 
    * @throws com.akcess.exception.Tipo_recursoException Es lanzado en el caso que no se encuentren ninguna fila en la BD.
    */ 
    public Tipo_recurso[] listarSubtipos() throws Tipo_recursoException{
        Tipo_recurso[] tipos = null;
        
            Tipo_recursoDAOImpl TipoDAO = new Tipo_recursoDAOImpl();
            tipos = TipoDAO.findAll(this.conexion);
        
        return tipos;
    }
    
     /**
     * Obtiene TODOS los Subtipos de Recursos existentes y las operaciones que pueden realizarse en 
     * cada modulo.
     * @return Un vector del tipo Tipo_tiene_atributos, que relaciona el id de cada Tipo con el id de cada atributo
     * que tiene cada subtipo.
     * @throws com.akcess.exception.Modulo_tiene_operacionException Lanza excepciones del tipo Modulo_tiene_operacionException, creada por el DAOGenerator.
     */
    public Tipo_tiene_atributos[] ObtenerTipoAtributo() throws Tipo_tiene_atributosException {
        Tipo_tiene_atributos[] modOper = null;
        try {
            Tipo_tiene_atributosDAOImpl subTipoDAO = new Tipo_tiene_atributosDAOImpl();
            modOper = subTipoDAO.findAll(this.conexion);
        } catch (Tipo_tiene_atributosException ex) {
            ex.printStackTrace();
        }
        return modOper;
    }
    public Tipo_recurso ObtenerTipo(int Tipo) throws Tipo_recursoException
    {
        Tipo_recursoDAOImpl manejaTipo=new Tipo_recursoDAOImpl();
        Tipo_recurso tp= manejaTipo.findByPrimaryKey(Tipo, this.conexion);
        return tp;
        
    }
}
